.TH std::multiset 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::multiset \- std::multiset

.SH Synopsis
   Defined in header <set>
   template<

       class Key,
       class Compare = std::less<Key>,                                \fB(1)\fP
       class Allocator = std::allocator<Key>

   > class multiset;
   namespace pmr {

       template<
           class Key,
           class Compare = std::less<Key>                             \fB(2)\fP \fI(since C++17)\fP
       > using multiset = std::multiset<Key, Compare,
   std::pmr::polymorphic_allocator<Key>>;

   }

   std::multiset is an associative container that contains a sorted set of objects of
   type Key. Unlike set, multiple keys with equivalent values are allowed. Sorting is
   done using the key comparison function Compare. Search, insertion, and removal
   operations have logarithmic complexity.

   Everywhere the standard library uses the Compare requirements, equivalence is
   determined by using the equivalence relation as described on Compare. In imprecise
   terms, two objects a and b are considered equivalent if neither compares less than
   the other: !comp(a, b) && !comp(b, a).

   The order of the elements that compare equivalent is the order of      \fI(since C++11)\fP
   insertion and does not change.

   std::multiset meets the requirements of Container, AllocatorAwareContainer,
   AssociativeContainer and ReversibleContainer.

.SH Template parameters

    This section is incomplete
    Reason: Add descriptions of the template parameters.

.SH Member types

   Member type             Definition
   key_type                Key
   value_type              Key
   size_type               Unsigned integer type (usually std::size_t)
   difference_type         Signed integer type (usually std::ptrdiff_t)
   key_compare             Compare
   value_compare           Compare
   allocator_type          Allocator
   reference               value_type&
   const_reference         const value_type&
                           Allocator::pointer                        \fI(until C++11)\fP
   pointer                 std::allocator_traits<Allocator>::pointer \fI(since C++11)\fP


                           Allocator::const_pointer                        (until
                                                                           C++11)
   const_pointer           std::allocator_traits<Allocator>::const_pointer (since
                                                                           C++11)


   iterator                Constant LegacyBidirectionalIterator to value_type
   const_iterator          LegacyBidirectionalIterator to const value_type
   reverse_iterator        std::reverse_iterator<iterator>
   const_reverse_iterator  std::reverse_iterator<const_iterator>
   node_type \fI(since C++17)\fP a specialization of node handle representing a container
                           node

.SH Member functions

   constructor   constructs the multiset
                 \fI(public member function)\fP
   destructor    destructs the multiset
                 \fI(public member function)\fP
   operator=     assigns values to the container
                 \fI(public member function)\fP
   get_allocator returns the associated allocator
                 \fI(public member function)\fP
.SH Iterators
   begin         returns an iterator to the beginning
   cbegin        \fI(public member function)\fP
   \fI(C++11)\fP
   end           returns an iterator to the end
   cend          \fI(public member function)\fP
   \fI(C++11)\fP
   rbegin        returns a reverse iterator to the beginning
   crbegin       \fI(public member function)\fP
   \fI(C++11)\fP
   rend          returns a reverse iterator to the end
   crend         \fI(public member function)\fP
   \fI(C++11)\fP
.SH Capacity
   empty         checks whether the container is empty
                 \fI(public member function)\fP
   size          returns the number of elements
                 \fI(public member function)\fP
   max_size      returns the maximum possible number of elements
                 \fI(public member function)\fP
.SH Modifiers
   clear         clears the contents
                 \fI(public member function)\fP
                 inserts elements
   insert        or nodes
                 \fI(since C++17)\fP
                 \fI(public member function)\fP
   insert_range  inserts a range of elements
   (C++23)       \fI(public member function)\fP
   emplace       constructs element in-place
   \fI(C++11)\fP       \fI(public member function)\fP
   emplace_hint  constructs elements in-place using a hint
   \fI(C++11)\fP       \fI(public member function)\fP
   erase         erases elements
                 \fI(public member function)\fP
   swap          swaps the contents
                 \fI(public member function)\fP
   extract       extracts nodes from the container
   \fI(C++17)\fP       \fI(public member function)\fP
   merge         splices nodes from another container
   \fI(C++17)\fP       \fI(public member function)\fP
.SH Lookup
   count         returns the number of elements matching specific key
                 \fI(public member function)\fP
   find          finds element with specific key
                 \fI(public member function)\fP
   contains      checks if the container contains element with specific key
   (C++20)       \fI(public member function)\fP
   equal_range   returns range of elements matching a specific key
                 \fI(public member function)\fP
   lower_bound   returns an iterator to the first element not less than the given key
                 \fI(public member function)\fP
   upper_bound   returns an iterator to the first element greater than the given key
                 \fI(public member function)\fP
.SH Observers
   key_comp      returns the function that compares keys
                 \fI(public member function)\fP
   value_comp    returns the function that compares keys in objects of type value_type
                 \fI(public member function)\fP

.SH Non-member functions

   operator==
   operator!=
   operator<
   operator<=
   operator>
   operator>=               lexicographically compares the values of two multisets
   operator<=>              \fI(function template)\fP
   (removed in C++20)
   (removed in C++20)
   (removed in C++20)
   (removed in C++20)
   (removed in C++20)
   (C++20)
   std::swap(std::multiset) specializes the std::swap algorithm
                            \fI(function template)\fP
   erase_if(std::multiset)  erases all elements satisfying specific criteria
   (C++20)                  \fI(function template)\fP

     Deduction guides \fI(since C++17)\fP

.SH Notes

   The member types iterator and const_iterator may be aliases to the same type. This
   means defining a pair of function overloads using the two types as parameter types
   may violate the One Definition Rule. Since iterator is convertible to
   const_iterator, a single function with a const_iterator as parameter type will work
   instead.

       Feature-test macro       Value    Std                   Feature
   __cpp_lib_containers_ranges 202202L (C++23) Ranges construction and insertion for
                                               containers

.SH Example

    This section is incomplete
    Reason: no example

   Defect reports

   The following behavior-changing defect reports were applied retroactively to
   previously published C++ standards.

     DR    Applied to           Behavior as published              Correct behavior
   LWG 103 C++98      iterator allows modification of keys      iterator made constant
                      Key was not required to be
   LWG 230 C++98      CopyConstructible                         Key is also required to
                      (a key of type Key might not be able to   be CopyConstructible
                      be constructed)

.SH Categories:
     * Todo with reason
     * Todo no example
